home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dc1 / genarith.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-09-09  |  14.1 KB  |  575 lines
  1. /*
  2.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  3.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  4.  *    DICE-LICENSE.TXT.
  5.  */
  6.  
  7. /*
  8.  *  GenArith.C
  9.  *
  10.  *  Normal arithmatic functions like +, -, /, % ..
  11.  *
  12.  *  NOTE:  +=, -=, etc.. with lhs bit fields, CreateBinaryResult will
  13.  *       bfext the lhs.  It is expected that the lhs is already freed.
  14.  */
  15.  
  16. /*
  17. **      $Filename: genarith.c $
  18. **      $Author: dice $
  19. **      $Revision: 30.157 $
  20. **      $Date: 1995/01/11 13:19:27 $
  21. **      $Log: genarith.c,v $
  22.  * Revision 30.157  1995/01/11  13:19:27  dice
  23.  * .
  24.  *
  25.  * Revision 30.0  1994/06/10  18:04:50  dice
  26.  * .
  27.  *
  28.  * Revision 1.3  1993/10/17  11:02:49  jtoebes
  29.  * FIXED BUG01133 - Strange warning about mismatch of return type for the assignment
  30.  * of a function pointer.  This change now causes the compiler to tell you the type
  31.  * that it was comparing with as well as the expected type.  This should help a lot
  32.  * of people in figuring out what the error was.
  33.  *
  34.  * Revision 1.2  1993/09/11  21:25:12  jtoebes
  35.  * Fixed BUG00108 - if (1, 0) not allowed
  36.  * Added in logic similar to GenNot to test for the condition and generate the
  37.  * branches as appropriate.  It also involves propagating the cond bits.
  38.  *
  39. **/
  40.  
  41. #include "defs.h"
  42.  
  43. Prototype void GenDiv(Exp **);
  44. Prototype void GenPercent(Exp **);
  45. Prototype void GenStar(Exp **);
  46. Prototype void GenMi(Exp **);
  47. Prototype void GenPl(Exp **);
  48. Prototype void GenNeg(Exp **);
  49. Prototype void GenParen(Exp **);
  50. Prototype void GenComma(Exp **);
  51.  
  52. void
  53. GenDiv(pexp)
  54. Exp **pexp;
  55. {
  56.     Exp *exp = *pexp;
  57.     Exp *e1;
  58.     Exp *e2;
  59.  
  60.     CallLeft();
  61.     EnsureReturnStorageLeft();
  62.     CallRight();
  63.  
  64.     if (GenPass == 0) {
  65.     OptBinaryArithRules(exp);
  66.  
  67.     e1 = exp->ex_ExpL;
  68.     e2 = exp->ex_ExpR;
  69.  
  70.     if (e1->ex_Stor.st_Type == ST_IntConst && e2->ex_Stor.st_Type == ST_IntConst) {
  71.         if (e2->ex_Stor.st_IntConst == 0) {
  72.         yerror(e2->ex_LexIdx, EERROR_CONST_DIVMOD_0);
  73.         e2->ex_Stor.st_IntConst = 1;
  74.         }
  75.         if (e1->ex_Type->Flags & TF_UNSIGNED)
  76.         e1->ex_Stor.st_UIntConst = (ulong)e1->ex_Stor.st_IntConst / (ulong)e2->ex_Stor.st_IntConst;
  77.         else
  78.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst / e2->ex_Stor.st_IntConst;
  79.         *pexp = e1;
  80.     } else if (e1->ex_Stor.st_Type == ST_FltConst && e2->ex_Stor.st_Type == ST_FltConst) {
  81.         ConstFpDiv(exp, &e1->ex_Stor, &e2->ex_Stor, &e1->ex_Stor);
  82.         *pexp = e1;
  83.     } else {
  84.         /*exp->ex_Flags |= (e1->ex_Flags | e2->ex_Flags) & EF_CALL;*/
  85.         exp->ex_Flags |= EF_CALL;    /*  XXX ask assembly if call made */
  86.         GenFlagCallMade();
  87.     }
  88.     } else {
  89.     e1 = exp->ex_ExpL;
  90.     e2 = exp->ex_ExpR;
  91.  
  92.     if (CreateBinaryResultStorage(exp, 1)) {
  93.         if (exp->ex_Type->Id == TID_FLT)
  94.         asm_fpdiv(exp, exp->ex_Type, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  95.         else
  96.         asm_div(exp, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor, 0);
  97.     }
  98.     }
  99. }
  100.  
  101. void
  102. GenPercent(pexp)
  103. Exp **pexp;
  104. {
  105.     Exp *exp = *pexp;
  106.     Exp *e1;
  107.     Exp *e2;
  108.  
  109.     CallLeft();
  110.     EnsureReturnStorageLeft();
  111.     CallRight();
  112.  
  113.     if (GenPass == 0) {
  114.     OptBinaryArithRules(exp);
  115.     /*BinaryArithRules(exp);*/
  116.  
  117.     e1 = exp->ex_ExpL;
  118.     e2 = exp->ex_ExpR;
  119.  
  120.     if (e1->ex_Stor.st_Type == ST_IntConst && e2->ex_Stor.st_Type == ST_IntConst) {
  121.         if (e2->ex_Stor.st_IntConst == 0) {
  122.         yerror(e2->ex_LexIdx, EERROR_CONST_DIVMOD_0);
  123.         e2->ex_Stor.st_IntConst = 1;
  124.         }
  125.         if (e1->ex_Type->Flags & TF_UNSIGNED)
  126.         e1->ex_Stor.st_UIntConst = (ulong)e1->ex_Stor.st_IntConst % (ulong)e2->ex_Stor.st_IntConst;
  127.         else
  128.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst % e2->ex_Stor.st_IntConst;
  129.         *pexp = e1;
  130.     } else {
  131.         /*exp->ex_Flags |= (e1->ex_Flags | e2->ex_Flags) & EF_CALL;*/
  132.         exp->ex_Flags |= EF_CALL;    /*  XXX ask assembly if call made */
  133.         GenFlagCallMade();
  134.     }
  135.     } else {
  136.     e1 = exp->ex_ExpL;
  137.     e2 = exp->ex_ExpR;
  138.  
  139.     if (CreateBinaryResultStorage(exp, 1))
  140.         asm_div(exp, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor, 1);
  141.     }
  142. }
  143.  
  144. void
  145. GenStar(pexp)
  146. Exp **pexp;
  147. {
  148.     Exp *exp = *pexp;
  149.     Exp *e1;
  150.     Exp *e2;
  151.  
  152.     CallLeft();
  153.     EnsureReturnStorageLeft();
  154.     CallRight();
  155.  
  156.     if (GenPass == 0) {
  157.     OptBinaryArithRules(exp);
  158.  
  159.  
  160.     e1 = exp->ex_ExpL;
  161.     e2 = exp->ex_ExpR;
  162.  
  163.     if (e1->ex_Stor.st_Type == ST_IntConst && e2->ex_Stor.st_Type == ST_IntConst) {
  164.         if (e1->ex_Type->Flags & TF_UNSIGNED)
  165.         e1->ex_Stor.st_UIntConst = (ulong)e1->ex_Stor.st_IntConst * (ulong)e2->ex_Stor.st_IntConst;
  166.         else
  167.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst * e2->ex_Stor.st_IntConst;
  168.         *pexp = e1;
  169.     } else if (e1->ex_Stor.st_Type == ST_FltConst && e2->ex_Stor.st_Type == ST_FltConst) {
  170.         ConstFpMul(exp, &e1->ex_Stor, &e2->ex_Stor, &e1->ex_Stor);
  171.         *pexp = e1;
  172.     } else {
  173.         /*exp->ex_Flags |= (e1->ex_Flags | e2->ex_Flags) & EF_CALL;*/
  174.         exp->ex_Flags |= EF_CALL;    /*  XXX ask assembly if call made */
  175.         GenFlagCallMade();
  176.     }
  177.     } else {
  178.     e1 = exp->ex_ExpL;
  179.     e2 = exp->ex_ExpR;
  180.  
  181.     if (CreateBinaryResultStorage(exp, 1)) {
  182.         if (exp->ex_Type->Id == TID_FLT)
  183.         asm_fpmul(exp, exp->ex_Type, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  184.         else
  185.         asm_mul(exp, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  186.     }
  187.     }
  188. }
  189.  
  190. void
  191. GenMi(pexp)
  192. Exp **pexp;
  193. {
  194.     Exp *exp = *pexp;
  195.     Exp *e1;
  196.     Exp *e2;
  197.  
  198.     /*
  199.      *    Note: since we do not know whether it is int - int or ptr - int or
  200.      *    ptr - ptr we try to optimize the lhs (which could be a ptr which will
  201.      *    not optimize) and only if it turns out to be an int may we optimize
  202.      *    the rhs.
  203.      */
  204.  
  205.     if (exp->ex_Type) {
  206.     e1 = exp->ex_ExpL;
  207.     if (e1->ex_Type == NULL)
  208.         e1->ex_Type = exp->ex_Type;
  209.     CallLeft();
  210.     if (exp->ex_ExpL->ex_Type->Id == TID_INT) {
  211.         e2 = exp->ex_ExpR;
  212.         if (e2->ex_Type == NULL)
  213.         e2->ex_Type = exp->ex_Type;
  214.     }
  215.     } else {
  216.     CallLeft();
  217.     }
  218.     EnsureReturnStorageLeft();
  219.  
  220.     if (GenPass == 0) {
  221.     if (exp->ex_Flags & EF_ASSEQ) {
  222.         Type *t = exp->ex_ExpL->ex_Type;
  223.         if (t->Id == TID_INT) {
  224.         if (exp->ex_ExpR->ex_Type == NULL)
  225.             exp->ex_ExpR->ex_Type = t;
  226.         exp->ex_Type = t;
  227.         }
  228.     }
  229.     CallRight();
  230.  
  231.     SubRules(exp);
  232.  
  233.     e1 = exp->ex_ExpL;
  234.     e2 = exp->ex_ExpR;
  235.  
  236.     if (e1->ex_Stor.st_Type == ST_IntConst && e2->ex_Stor.st_Type == ST_IntConst) {
  237.         switch(exp->ex_Token) {
  238.         case 0:
  239.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst - e2->ex_Stor.st_IntConst;
  240.         break;
  241.         case 1:
  242.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst - exp->ex_Type->SubType->Size * e2->ex_Stor.st_IntConst;
  243.         break;
  244.         case 2:
  245.         if (e1->ex_Type->SubType->Size != e2->ex_Type->SubType->Size)
  246.         {
  247.                 CheckPointerType(e1->ex_LexIdx, e2->ex_LexIdx, e1->ex_Type, e2->ex_Type);
  248. /*            yerror(e2->ex_LexIdx, EERROR_PTR_PTR_MISMATCH); */
  249.         }
  250.         if (e1->ex_Type->SubType->Size)
  251.         {
  252.             e1->ex_Stor.st_IntConst =
  253.             (e1->ex_Stor.st_IntConst - e2->ex_Stor.st_IntConst) /
  254.                 e1->ex_Type->SubType->Size;
  255.         }
  256.         else
  257.         {
  258.              yerror(e2->ex_LexIdx, EERROR_UNEXPECTED_VOID_TYPE);
  259.         }
  260.         break;
  261.         }
  262.         e1->ex_Type = exp->ex_Type;
  263.         *pexp = e1;
  264.     } else if (e1->ex_Stor.st_Type == ST_FltConst && e2->ex_Stor.st_Type == ST_FltConst) {
  265.         ConstFpSub(exp, &e1->ex_Stor, &e2->ex_Stor, &e1->ex_Stor);
  266.         *pexp = e1;
  267.     } else {
  268.         short makecall = 0;
  269.  
  270.         exp->ex_Flags |= (e1->ex_Flags | e2->ex_Flags) & EF_CALL;
  271.         if (exp->ex_Type->Id == TID_FLT) {
  272.         makecall = 1;
  273.         } else {
  274.         switch(exp->ex_Token) {
  275.         case 1:     /*    ptr - int   */
  276.             if (asm_mul_requires_call(-exp->ex_Type->SubType->Size))
  277.             makecall = 1;
  278.             break;
  279.         case 2:     /*    ptr - ptr   */
  280.             if (PowerOfTwo(e1->ex_Type->SubType->Size) < 0)
  281.             makecall = 1;
  282.             break;
  283.         }
  284.         }
  285.         if (makecall) {
  286.         exp->ex_Flags |= EF_CALL;
  287.         GenFlagCallMade();
  288.         }
  289.     }
  290.     } else {
  291.     Stor con;
  292.  
  293.     CallRight();
  294.     e1 = exp->ex_ExpL;
  295.     e2 = exp->ex_ExpR;
  296.  
  297.     switch(exp->ex_Token) {
  298.     case 0:
  299.         if (CreateBinaryResultStorage(exp, 1)) {
  300.         if (exp->ex_Type->Id == TID_FLT)
  301.             asm_fpsub(exp, exp->ex_Type, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  302.         else
  303.             asm_sub(exp, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  304.         }
  305.         break;
  306.     case 1: /*  ptr - int    */
  307.         if (exp->ex_Flags & (EF_PRES|EF_ASSEQ)) {
  308.         CreateBinaryResultStorage(exp, 1);
  309.         asm_getindex(exp, e1->ex_Type, &e1->ex_Stor, &e2->ex_Stor, exp->ex_Type->SubType->Size, &exp->ex_Stor, -1, 1);
  310.         } else {
  311.         FreeStorage(&e1->ex_Stor);
  312.         FreeStorage(&e2->ex_Stor);
  313.         if ((exp->ex_Flags & EF_RNU) == 0)
  314.             asm_getindex(exp, e1->ex_Type, &e1->ex_Stor, &e2->ex_Stor, exp->ex_Type->SubType->Size, &exp->ex_Stor, -1, 0);
  315.         }
  316.         break;
  317.     case 2: /*  ptr - ptr    */
  318.         if (CreateBinaryResultStorage(exp, 1)) {
  319.         asm_sub(exp, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  320.         if (e1->ex_Type->SubType->Size > 1) {
  321.             short n;
  322.  
  323.             AllocConstStor(&con, e1->ex_Type->SubType->Size, &LongType);
  324.  
  325.             /*
  326.              *    If power of 2 can use ASR since pointers are expected to be
  327.              *    a multiple of the SubType->Size apart.    Thus, 0 never occurs
  328.              *    for negative quantities (unless already 0).
  329.              */
  330.  
  331.             if ((n = PowerOfTwo(con.st_IntConst)) >= 0) {
  332.             con.st_IntConst = n;
  333.             asm_shift(exp, 1, &exp->ex_Stor, &con, &exp->ex_Stor);
  334.             } else {
  335.             asm_div(exp, &exp->ex_Stor, &con, &exp->ex_Stor, 0);
  336.             }
  337.         }
  338.         }
  339.         break;
  340.     default:
  341.         Assert(0);
  342.         break;
  343.     }
  344.     }
  345. }
  346.  
  347.  
  348. void
  349. GenPl(pexp)
  350. Exp **pexp;
  351. {
  352.     Exp *exp = *pexp;
  353.     Exp *e1;
  354.     Exp *e2;
  355.  
  356.     /*
  357.      *    store-down optimize integer adds cannot be accomplished at the
  358.      *    moment because we do not know about the int + ptr case.
  359.      */
  360.  
  361.     CallLeft();
  362.     EnsureReturnStorageLeft();
  363.  
  364.     if (GenPass == 0) {
  365.     if (exp->ex_Flags & EF_ASSEQ) {
  366.         Type *t = exp->ex_ExpL->ex_Type;
  367.         if (t->Id == TID_INT) {
  368.         if (exp->ex_ExpR->ex_Type == NULL)
  369.             exp->ex_ExpR->ex_Type = t;
  370.         exp->ex_Type = t;
  371.         }
  372.     }
  373.     CallRight();
  374.  
  375.     AddRules(exp);
  376.  
  377.     e1 = exp->ex_ExpL;
  378.     e2 = exp->ex_ExpR;
  379.  
  380.     if (e1->ex_Stor.st_Type == ST_IntConst && e2->ex_Stor.st_Type == ST_IntConst) {
  381.         if (exp->ex_Token)
  382.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst + exp->ex_Type->SubType->Size * e2->ex_Stor.st_IntConst;
  383.         else
  384.         e1->ex_Stor.st_IntConst = e1->ex_Stor.st_IntConst + e2->ex_Stor.st_IntConst;
  385.         e1->ex_Type = exp->ex_Type;
  386.         *pexp = e1;
  387.     } else if (e1->ex_Stor.st_Type == ST_FltConst && e2->ex_Stor.st_Type == ST_FltConst) {
  388.         ConstFpAdd(exp, &e1->ex_Stor, &e2->ex_Stor, &e1->ex_Stor);
  389.         *pexp = e1;
  390.     } else {
  391.         short makecall = 0;
  392.  
  393.         exp->ex_Flags |= (e1->ex_Flags | e2->ex_Flags) & EF_CALL;
  394.         if (exp->ex_Type->Id == TID_FLT) {
  395.         makecall = 1;
  396.         } else {
  397.         if (exp->ex_Token && e2->ex_Stor.st_Type != ST_IntConst) {
  398.             if (asm_mul_requires_call(exp->ex_Type->SubType->Size))
  399.             makecall = 1;
  400.         }
  401.         }
  402.         if (makecall) {
  403.         exp->ex_Flags |= EF_CALL;
  404.         GenFlagCallMade();
  405.         }
  406.     }
  407.     } else {
  408.     CallRight();
  409.     e1 = exp->ex_ExpL;
  410.     e2 = exp->ex_ExpR;
  411.  
  412.     if (exp->ex_Token) {
  413.         if (exp->ex_Flags & (EF_PRES|EF_ASSEQ)) {
  414.         CreateBinaryResultStorage(exp, 1);
  415.         asm_getindex(exp, e1->ex_Type, &e1->ex_Stor, &e2->ex_Stor, exp->ex_Type->SubType->Size, &exp->ex_Stor, 1, 1);
  416.         } else {
  417.         FreeStorage(&e1->ex_Stor);
  418.         FreeStorage(&e2->ex_Stor);
  419.         if ((exp->ex_Flags & EF_RNU) == 0)
  420.             asm_getindex(exp, e1->ex_Type, &e1->ex_Stor, &e2->ex_Stor, exp->ex_Type->SubType->Size, &exp->ex_Stor, 1, 0);
  421.         }
  422.     } else {
  423.         if (CreateBinaryResultStorage(exp, 1)) {
  424.         if (exp->ex_Type->Id == TID_FLT)
  425.             asm_fpadd(exp, exp->ex_Type, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  426.         else
  427.             asm_add(exp, &e1->ex_Stor, &e2->ex_Stor, &exp->ex_Stor);
  428.         } else {
  429.         FreeStorage(&e1->ex_Stor);
  430.         FreeStorage(&e2->ex_Stor);
  431.         }
  432.     }
  433.     }
  434. }
  435.  
  436. void
  437. GenNeg(pexp)
  438. Exp **pexp;
  439. {
  440.     Exp *exp = *pexp;
  441.     Exp *e1;
  442.  
  443.     if (exp->ex_Type && exp->ex_ExpL->ex_Type == NULL)
  444.     exp->ex_ExpL->ex_Type = exp->ex_Type;
  445.  
  446.     CallLeft();
  447.  
  448.     if (GenPass == 0) {
  449.     UnaryArithRules(exp);
  450.  
  451.     e1 = exp->ex_ExpL;
  452.  
  453.     switch(e1->ex_Stor.st_Type) {
  454.     case ST_IntConst:
  455.         e1->ex_Stor.st_IntConst = -e1->ex_Stor.st_IntConst;
  456.         e1->ex_Type = (e1->ex_Type->Flags & TF_UNSIGNED) ? &ULongType : &LongType;
  457.         *pexp = e1;
  458.         break;
  459.     case ST_FltConst:
  460.         ConstFpNeg(exp, &e1->ex_Stor, &e1->ex_Stor);
  461.         *pexp = e1;
  462.         break;
  463.     default:
  464.         exp->ex_Flags |= e1->ex_Flags & EF_CALL;
  465.         if (exp->ex_Type->Id == TID_FLT) {
  466.         exp->ex_Flags |= EF_CALL;
  467.         GenFlagCallMade();
  468.         }
  469.         break;
  470.     }
  471.     } else {
  472.     e1 = exp->ex_ExpL;
  473.  
  474.     if (CreateUnaryResultStorage(exp, 1)) {
  475.         if (exp->ex_Type->Id == TID_FLT)
  476.         asm_fpneg(exp, exp->ex_Type, &e1->ex_Stor, &exp->ex_Stor);
  477.         else
  478.         asm_neg(exp, &e1->ex_Stor, &exp->ex_Stor);
  479.     }
  480.     }
  481. }
  482.  
  483. void
  484. GenParen(pexp)
  485. Exp **pexp;
  486. {
  487.     Exp *exp = *pexp;
  488.     Exp *e1 = exp->ex_ExpL;
  489.  
  490.     if (e1 == NULL) {
  491.     if (GenPass == 0) {
  492.         exp->ex_Type = &VoidType;
  493.     } else {
  494.         if ((exp->ex_Flags & EF_RNU) == 0)
  495.         yerror(exp->ex_LexIdx, EERROR_UNEXPECTED_VOID_TYPE);
  496.     }
  497.     return;
  498.     }
  499.  
  500.     if (e1->ex_Type == NULL)
  501.     e1->ex_Type = exp->ex_Type;    /*  optimize storage    */
  502.     e1->ex_Flags = exp->ex_Flags;
  503.     *pexp = exp->ex_ExpL;
  504.     (*exp->ex_ExpL->ex_Func)(pexp);
  505. }
  506.  
  507. void
  508. GenComma(pexp)
  509. Exp **pexp;
  510. {
  511.     Exp *exp = *pexp;
  512.     Exp *e1;
  513.     Exp *e2;
  514.  
  515.     if (GenPass == 0) {
  516.     e1 = exp->ex_ExpL;
  517.     e2 = exp->ex_ExpR;
  518.     e1->ex_Flags |= EF_RNU;
  519.     if (exp->ex_Flags & EF_RNU)
  520.         e2->ex_Flags |= EF_RNU;
  521.     CallLeft();
  522.     CallRight();
  523.  
  524.     e1 = exp->ex_ExpL;
  525.     e2 = exp->ex_ExpR;
  526.  
  527.     exp->ex_Type = e2->ex_Type;
  528.  
  529.     if (e1->ex_Stor.st_Type == ST_IntConst && e2->ex_Stor.st_Type == ST_IntConst)
  530.         *pexp = e2;
  531.     else
  532.         exp->ex_Flags |= (e1->ex_Flags | e2->ex_Flags) & EF_CALL;
  533.     } else {
  534.     CallLeft();
  535.  
  536.     e2 = exp->ex_ExpR;
  537.     if (exp->ex_Flags & EF_COND) {
  538.         e2->ex_Flags |= EF_COND;
  539.         e2->ex_Cond   = exp->ex_Cond;
  540.         e2->ex_LabelT = exp->ex_LabelT;
  541.         e2->ex_LabelF = exp->ex_LabelF;
  542.     }
  543.  
  544.     CallRight();
  545.  
  546.     if ((exp->ex_Flags & EF_COND) && (e2->ex_Flags & EF_CONDACK)) {
  547.         exp->ex_Flags |= EF_CONDACK;
  548.     } else {
  549.         if ((exp->ex_Flags & EF_RNU) == 0) {
  550.         if (exp->ex_Flags & EF_PRES)
  551.             asm_move(exp, &e2->ex_Stor, &exp->ex_Stor);
  552.         else
  553.             ReuseStorage(&e2->ex_Stor, &exp->ex_Stor);
  554.         }
  555.     }
  556.  
  557. #ifdef NOTDEF
  558.     if (exp->ex_Flags & EF_COND) {
  559.         if (e2->ex_Flags & EF_CONDACK)
  560.         exp->ex_Flags |= EF_CONDACK;
  561.     } else {
  562.         if ((exp->ex_Flags & EF_RNU) == 0)
  563.         {
  564.         if (exp->ex_Flags & EF_PRES)
  565.             asm_move(exp, &e2->ex_Stor, &exp->ex_Stor);
  566.         else
  567.             ReuseStorage(&e2->ex_Stor, &exp->ex_Stor);
  568.         }
  569.     }
  570. #endif
  571.     FreeStorage(&e2->ex_Stor);
  572.     }
  573. }
  574.  
  575.